home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1997 April / macformat-049.iso / mac / Shareware Plus / Developers / dropg++ / usr / include / sys / socketvar.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-20  |  8.0 KB  |  208 lines  |  [TEXT/R*ch]
  1. /*-
  2.  * Copyright (c) 1982, 1986, 1990, 1993
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  *    @(#)socketvar.h    8.1 (Berkeley) 6/2/93
  34.  */
  35.  
  36. #include <sys/select.h>            /* for struct selinfo */
  37.  
  38. /*
  39.  * Kernel structure per socket.
  40.  * Contains send and receive buffer queues,
  41.  * handle on protocol and pointer to protocol
  42.  * private data and error information.
  43.  */
  44. struct socket {
  45.     short    so_type;        /* generic type, see socket.h */
  46.     short    so_options;        /* from socket call, see socket.h */
  47.     short    so_linger;        /* time to linger while closing */
  48.     short    so_state;        /* internal state flags SS_*, below */
  49.     caddr_t    so_pcb;            /* protocol control block */
  50.     struct    protosw *so_proto;    /* protocol handle */
  51. /*
  52.  * Variables for connection queueing.
  53.  * Socket where accepts occur is so_head in all subsidiary sockets.
  54.  * If so_head is 0, socket is not related to an accept.
  55.  * For head socket so_q0 queues partially completed connections,
  56.  * while so_q is a queue of connections ready to be accepted.
  57.  * If a connection is aborted and it has so_head set, then
  58.  * it has to be pulled out of either so_q0 or so_q.
  59.  * We allow connections to queue up based on current queue lengths
  60.  * and limit on number of queued connections for this socket.
  61.  */
  62.     struct    socket *so_head;    /* back pointer to accept socket */
  63.     struct    socket *so_q0;        /* queue of partial connections */
  64.     struct    socket *so_q;        /* queue of incoming connections */
  65.     short    so_q0len;        /* partials on so_q0 */
  66.     short    so_qlen;        /* number of connections on so_q */
  67.     short    so_qlimit;        /* max number queued connections */
  68.     short    so_timeo;        /* connection timeout */
  69.     u_short    so_error;        /* error affecting connection */
  70.     pid_t    so_pgid;        /* pgid for signals */
  71.     u_long    so_oobmark;        /* chars to oob mark */
  72. /*
  73.  * Variables for socket buffering.
  74.  */
  75.     struct    sockbuf {
  76.         u_long    sb_cc;        /* actual chars in buffer */
  77.         u_long    sb_hiwat;    /* max actual char count */
  78.         u_long    sb_mbcnt;    /* chars of mbufs used */
  79.         u_long    sb_mbmax;    /* max chars of mbufs to use */
  80.         long    sb_lowat;    /* low water mark */
  81.         struct    mbuf *sb_mb;    /* the mbuf chain */
  82.         struct    selinfo sb_sel;    /* process selecting read/write */
  83.         short    sb_flags;    /* flags, see below */
  84.         short    sb_timeo;    /* timeout for read/write */
  85.     } so_rcv, so_snd;
  86. #define    SB_MAX        (256*1024)    /* default for max chars in sockbuf */
  87. #define    SB_LOCK        0x01        /* lock on data queue */
  88. #define    SB_WANT        0x02        /* someone is waiting to lock */
  89. #define    SB_WAIT        0x04        /* someone is waiting for data/space */
  90. #define    SB_SEL        0x08        /* someone is selecting */
  91. #define    SB_ASYNC    0x10        /* ASYNC I/O, need signals */
  92. #define    SB_NOTIFY    (SB_WAIT|SB_SEL|SB_ASYNC)
  93. #define    SB_NOINTR    0x40        /* operations not interruptible */
  94.  
  95.     caddr_t    so_tpcb;        /* Wisc. protocol control block XXX */
  96.     void    (*so_upcall) __P((struct socket *so, caddr_t arg, int waitf));
  97.     caddr_t    so_upcallarg;        /* Arg for above */
  98. };
  99.  
  100. /*
  101.  * Socket state bits.
  102.  */
  103. #define    SS_NOFDREF        0x001    /* no file table ref any more */
  104. #define    SS_ISCONNECTED        0x002    /* socket connected to a peer */
  105. #define    SS_ISCONNECTING        0x004    /* in process of connecting to peer */
  106. #define    SS_ISDISCONNECTING    0x008    /* in process of disconnecting */
  107. #define    SS_CANTSENDMORE        0x010    /* can't send more data to peer */
  108. #define    SS_CANTRCVMORE        0x020    /* can't receive more data from peer */
  109. #define    SS_RCVATMARK        0x040    /* at mark on input */
  110.  
  111. #define    SS_PRIV            0x080    /* privileged for broadcast, raw... */
  112. #define    SS_NBIO            0x100    /* non-blocking ops */
  113. #define    SS_ASYNC        0x200    /* async i/o notify */
  114. #define    SS_ISCONFIRMING        0x400    /* deciding to accept connection req */
  115.  
  116.  
  117. /*
  118.  * Macros for sockets and socket buffering.
  119.  */
  120.  
  121. /*
  122.  * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
  123.  * This is problematical if the fields are unsigned, as the space might
  124.  * still be negative (cc > hiwat or mbcnt > mbmax).  Should detect
  125.  * overflow and return 0.  Should use "lmin" but it doesn't exist now.
  126.  */
  127. #define    sbspace(sb) \
  128.     ((long) imin((int)((sb)->sb_hiwat - (sb)->sb_cc), \
  129.      (int)((sb)->sb_mbmax - (sb)->sb_mbcnt)))
  130.  
  131. /* do we have to send all at once on a socket? */
  132. #define    sosendallatonce(so) \
  133.     ((so)->so_proto->pr_flags & PR_ATOMIC)
  134.  
  135. /* can we read something from so? */
  136. #define    soreadable(so) \
  137.     ((so)->so_rcv.sb_cc >= (so)->so_rcv.sb_lowat || \
  138.     ((so)->so_state & SS_CANTRCVMORE) || \
  139.     (so)->so_qlen || (so)->so_error)
  140.  
  141. /* can we write something to so? */
  142. #define    sowriteable(so) \
  143.     (sbspace(&(so)->so_snd) >= (so)->so_snd.sb_lowat && \
  144.     (((so)->so_state&SS_ISCONNECTED) || \
  145.       ((so)->so_proto->pr_flags&PR_CONNREQUIRED)==0) || \
  146.      ((so)->so_state & SS_CANTSENDMORE) || \
  147.      (so)->so_error)
  148.  
  149. /* adjust counters in sb reflecting allocation of m */
  150. #define    sballoc(sb, m) { \
  151.     (sb)->sb_cc += (m)->m_len; \
  152.     (sb)->sb_mbcnt += MSIZE; \
  153.     if ((m)->m_flags & M_EXT) \
  154.         (sb)->sb_mbcnt += (m)->m_ext.ext_size; \
  155. }
  156.  
  157. /* adjust counters in sb reflecting freeing of m */
  158. #define    sbfree(sb, m) { \
  159.     (sb)->sb_cc -= (m)->m_len; \
  160.     (sb)->sb_mbcnt -= MSIZE; \
  161.     if ((m)->m_flags & M_EXT) \
  162.         (sb)->sb_mbcnt -= (m)->m_ext.ext_size; \
  163. }
  164.  
  165. /*
  166.  * Set lock on sockbuf sb; sleep if lock is already held.
  167.  * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
  168.  * Returns error without lock if sleep is interrupted.
  169.  */
  170. #define sblock(sb, wf) ((sb)->sb_flags & SB_LOCK ? \
  171.         (((wf) == M_WAITOK) ? sb_lock(sb) : EWOULDBLOCK) : \
  172.         ((sb)->sb_flags |= SB_LOCK), 0)
  173.  
  174. /* release lock on sockbuf sb */
  175. #define    sbunlock(sb) { \
  176.     (sb)->sb_flags &= ~SB_LOCK; \
  177.     if ((sb)->sb_flags & SB_WANT) { \
  178.         (sb)->sb_flags &= ~SB_WANT; \
  179.         wakeup((caddr_t)&(sb)->sb_flags); \
  180.     } \
  181. }
  182.  
  183. #define    sorwakeup(so)    { sowakeup((so), &(so)->so_rcv); \
  184.               if ((so)->so_upcall) \
  185.                 (*((so)->so_upcall))((so), (so)->so_upcallarg, M_DONTWAIT); \
  186.             }
  187.  
  188. #define    sowwakeup(so)    sowakeup((so), &(so)->so_snd)
  189.  
  190. #ifdef KERNEL
  191. u_long    sb_max;
  192. /* to catch callers missing new second argument to sonewconn: */
  193. #define    sonewconn(head, connstatus)    sonewconn1((head), (connstatus))
  194. struct    socket *sonewconn1 __P((struct socket *head, int connstatus));
  195.  
  196. /* strings for sleep message: */
  197. extern    char netio[], netcon[], netcls[];
  198.  
  199. /*
  200.  * File operations on sockets.
  201.  */
  202. int    soo_read __P((struct file *fp, struct uio *uio, struct ucred *cred));
  203. int    soo_write __P((struct file *fp, struct uio *uio, struct ucred *cred));
  204. int    soo_ioctl __P((struct file *fp, int com, caddr_t data, struct proc *p));
  205. int    soo_select __P((struct file *fp, int which, struct proc *p));
  206. int     soo_close __P((struct file *fp, struct proc *p));
  207. #endif
  208.